/*游戏执行类，main
 * 1个方法：指定命中率
 * 4个对象：战士，骑兵，法师，电脑
 * 4个变量：角色，对手，对战双方，回合数
 * 1个函数：产生指定的命中率
 * author:@杨陈菊
 */
 /*
import GameUtil;   //引入父类（描述战斗单元的类）
import Soilder;    //引入战士的类
import Cavalry;    //引入骑兵的类
import Magian;     //引入法师的类
*/
import java.util.Random;//引入Random类
import java.util.Scanner;//导入java.util包下的Scanner类，以读取来自System.in的输入

public class GameStart {

    public static void main(String[] args) {
        Soilder soilder = new Soilder();    //创建一个战士对象
        Cavalry cavalry = new Cavalry();    //创建一个骑兵对象
        Magian magain = new Magian();       //创建一个法师对象
        GameUtil computer = new GameUtil(); //创建一个电脑对象
        Scanner input=new Scanner(System.in);//创建一个Scanner对象input
        //声明变量
        String role = "";    //声明变量cole,用于获取从控制台输入角色
        String opponent = "";//声明变量opponent,用于获取从控制台选择的对手
        String battle="";    //声明变量battle,用于选择对战过程
        int number = 1;      //用于记录回合数
        //背景说明

        //规则说明
        System.out.printf("在这个游戏中，你需要通过选择自己代表的角色与对手角色进行PK\n");
        //提示玩家进行选择
        System.out.println("请选择一个角色代表你自己，并输入角色编号：");
        System.out.println("A:战士");
        System.out.println("B:骑士");
        System.out.println("C:法师");
        role = input.nextLine();//获取玩家输入的角色选择
        String a1 = String.valueOf('a');
        String a2 = String.valueOf('A');
        String a3 = String.valueOf('b');
        String a4 = String.valueOf('B');
        String a5 = String.valueOf('c');
        String a6 = String.valueOf('C');
        if(a1 == role || a2 == role)
            System.out.println("你选择了战士，他的初始生命值是100，攻击力是10，防御抵消是12");
        else if(a3 == role || a4 == role)
            System.out.println("你选择了骑士，他的初始生命值是80，攻击力是15，防御抵消是12");
        else if(a5 == role || a6 == role)
            System.out.println("你选择了法师，他的初始生命值是50，攻击力是25，防御抵消是5");
        System.out.println("请选择一个对手，并输入对手编号：");
        System.out.println("A:战士");
        System.out.println("B:骑士");
        System.out.println("C:法师");
        System.out.println("D:电脑");
        opponent = input.nextLine();//获取玩家选择的对手
        //角色和对手不能相同
        if(role.equals(opponent)) {//字符串之间的比较
            System.out.println("角色和对手不能相同,请重新选择对手：");
            opponent = input.nextLine();//重新获取从控制台选择的对手
        }
        if(a1 == opponent || a2 == opponent)
            System.out.println("你选择了你的对手是战士，他的初始生命值是100，攻击力是10，防御抵消是12");
        else if(a3 == opponent || a4 == opponent)
            System.out.println("你选择了你的对手是骑士，他的初始生命值是80，攻击力是15，防御抵消是12");
        else if(a5 == opponent || a6 == opponent)
            System.out.println("你选择了你的对手是法师，他的初始生命值是50，攻击力是25，防御抵消是5");
        else
            System.out.println("你选择了你的对手是电脑，他的初始生命值是80，攻击力是15，防御抵消是5");
        //System.out.println(soilder.getAttack());
        /*
         * 选择对战对象
         */
        battle = role + opponent;  //用于对战双方角色限定
        switch(battle) {
            //战士对电脑
            case "AD": {
//                System.out.println("");                   //空一行
//                System.out.println("战士 VS 电脑");
//                //int number = 0;       //用于记录回合数
//                while(computer.die() && soilder.die()) {  //双方都活着，循环继续
//                    number++;            //循环一次自增1，表示回合数
//                    System.out.println("第"+number+"回合：");//每回合输出回合数
//
//                    if(mingZhong(soilder.getHr())==1) {    //战士打中电脑
//                        computer.fangyu(soilder.getAttack());//电脑做出防御
//                    }else {
//                        computer.dodge();//战士没有打中电脑，调用父类躲闪函数
//                    }
//                    if(mingZhong(computer.getHr())==1 && computer.getLife() > 0) {//电脑还活着，并且电脑打中了战士
//                        soilder.fangyu(computer.getAttack());      //战士做出防御
//                    }
//                    if(mingZhong(computer.getHr())==0 && computer.getLife() > 0) { //电脑还活着，但没有打中战士
//                        soilder.dodge();           //调用Soilder子类重写的躲闪函数
//                    }
//                }
//                break;
                Scanner scanner = new Scanner(System.in);
                System.out.println("");
                System.out.println("战士 VS 电脑");
                while (computer.die() && soilder.die() && number < 7) {  //双方都活着且在7个回合之内，循环继续
                    System.out.println("第" + number + "回合：");//每回合输出回合数
                    System.out.println("请输入你的选择（1-攻击，2-防御）：");
                    int soldierChoice = scanner.nextInt();
                    if (soldierChoice == 1) {
                        if (mingZhong(soilder.getHr()) == 1) {    //战士打中电脑
                            computer.fangyu(soilder.getAttack());//电脑做出防御
                            if (computer.getLife() > 0) { // 电脑还活着
                                System.out.println("电脑的选择是：攻击");
                                if (mingZhong(computer.getHr()) == 1) { // 电脑打中了战士
                                    soilder.fangyu(computer.getAttack());    //战士做出防御
                                } else {
                                    soilder.dodge();           //调用Soilder子类重写的躲闪函数
                                }
                            }
                        } else {
                            computer.dodge();//战士没有打中电脑，调用父类躲闪函数
                        }
                    } else if (soldierChoice == 2) {
                        soilder.fangyu(computer.attack); // 战士选择防御
                        if (computer.getLife() > 0) { // 电脑还活着
                            System.out.println("电脑的选择是：攻击");
                            if (mingZhong(computer.getHr()) == 1) { // 电脑打中了战士
                                soilder.fangyu(computer.getAttack());    //战士做出防御
                            } else {
                                soilder.dodge();           //调用Soilder子类重写的躲闪函数
                            }
                        }
                    }else{
                        System.out.println("不支持该选择，请重新输入");
                    }
                    number++; //回合数自增1
                }

                scanner.close();
                break;
            }
            //骑兵对电脑
            case "BD":{
                System.out.println("");
                System.out.println("骑兵 vs 电脑");
                while(computer.die() && cavalry.die()) {   //双方都活着，循环继续
                    number++;       //循环一次自增1，表示回合数
                    System.out.println("第"+number+"回合：");//每回合输出回合数
                    if(mingZhong(cavalry.getHr())==1) {    //骑骑兵打中电脑
                        computer.fangyu(cavalry.getAttack());//电脑防御
                    }else {
                        computer.dodge();     //骑兵没有打中电脑，调用父类躲闪函数函数
                    }
                    if(mingZhong(computer.getHr())==1 && computer.getLife() > 0) {//电脑活着，打中骑兵
                        cavalry.fangyu(computer.getAttack());    //骑兵防御
                    }
                    if(mingZhong(computer.getHr())==0 && computer.getLife() > 0) {//电脑活着，没有打中骑兵
                        cavalry.dodge();      //调用Cavalry子类重写的躲闪函数
                    }
                    if(number == 6){

                    }
                }
                break;
            }
            //法师对电脑
            case "CD":{
                System.out.println("");
                System.out.println("法师 vs 电脑");
                while(computer.die() && magain.die()) {      //双方都活着，循环继续
                    number++;         //循环一次自增1，表示回合数
                    System.out.println("第"+number+"回合：");  //每回合输出回合数
                    if(mingZhong(magain.getHr())==1) {        //法师打中电脑
                        computer.fangyu(magain.getAttack());  //电脑防御
                    }else {
                        computer.dodge();      //法师没有打中电脑，调用父类躲闪函数函数
                    }
                    if(mingZhong(computer.getHr())==1 && computer.getLife() > 0) {//电脑活着，打中法师
                        magain.fangyu(computer.getAttack());    //法师防御
                    }
                    if(mingZhong(computer.getHr())==0 && computer.getLife() > 0) {//电脑活着，没有打中法师
                        magain.dodge();    //调用Magain子类重写的躲闪函数
                    }
                }
                break;
            }
            //战士对骑兵
            case "AB":{
                System.out.println("");
                System.out.println("战士 vs 骑兵");
                while(cavalry.die() && soilder.die()) {     //双方都活着，循环继续
                    number++;   //循环一次自增1，表示回合数
                    System.out.println("第"+number+"回合：");//每回合输出回合数
                    if(mingZhong(soilder.getHr())==1) {    //战士打中骑兵
                        cavalry.fangyu(soilder.getAttack());//骑兵防御
                    }else {
                        cavalry.dodge();  //战士没有打中骑兵，调用Cavalry子类重写的躲闪函数
                    }
                    if(mingZhong(cavalry.getHr())==1 && cavalry.getLife() > 0) {//骑兵当前生命值大于0（即活着），并且打中战士
                        soilder.fangyu(cavalry.getAttack());    //战士防御
                    }
                    if(mingZhong(cavalry.getHr())==0 && cavalry.getLife() > 0) {//骑兵活着，没有打中战士
                        soilder.dodge();   //调用Soilder子类重写的躲闪函数
                    }
                }
                break;
            }
            //战士会法师
            case "AC":{
                System.out.println("");
                System.out.println("战士 vs 法师");
                while(magain.die() && soilder.die()) {     //双方活着，循环继续
                    number++;    //循环一次自增1，表示回合数
                    System.out.println("第"+number+"回合：");//每回合输出回合数
                    if(mingZhong(soilder.getHr())==1) {     //战士打中法师
                        magain.fangyu(soilder.getAttack());//法师防御
                    }else {
                        magain.dodge();   //战士没有打中法师，调用Magain子类重写的躲闪函数
                    }
                    if(mingZhong(magain.getHr())==1 && magain.getLife() > 0) {//法师活着，打中战士
                        soilder.fangyu(magain.getAttack()); //战士防御
                    }
                    if(mingZhong(magain.getHr())==0 && magain.getLife() > 0) {//法师活着。未打中战士
                        soilder.dodge();    //调用Soilder子类重写的躲闪函数
                    }
                }
                break;
            }
            //骑兵对法师
            case "BC":{
                System.out.println("");
                System.out.println("骑兵 vs 法师");
                while(magain.die() && cavalry.die()) {     //双方或者，循环继续
                    number++;   //循环一次自增1，表示回合数
                    System.out.println("第"+number+"回合：");//每回合输出回合数
                    if(mingZhong(cavalry.getHr())==1) {     //骑兵打中法师
                        magain.fangyu(cavalry.getAttack());  //法师防御
                    }else {
                        magain.dodge();  //骑兵为打中骑兵，调用Magain子类重写的躲闪函数
                    }
                    if(mingZhong(magain.getHr())==1 && magain.getLife() > 0) {//法师活着，打中骑兵
                        cavalry.fangyu(magain.getAttack());    //骑兵防御
                    }
                    if(mingZhong(magain.getHr())==0 && magain.getLife() > 0) { //法师活着，为打中骑兵
                        cavalry.dodge();     //调用Cavalry子类重写的躲闪函数
                    }
                }
                break;
            }
        }
    }
    //实现指定命中率的函数
    public static int mingZhong(double hr) {
        Random r = new Random();
        int flag=0;//意味着，不攻击
        //随机产生[0;1],0出现的概率为hr，1出现的概率为1-hr
        int a = r.nextInt(100);//随机产生[0,100)的整数，每个数字出现的概率为1%
        if(a<(int) (hr*100)){ //前hr*100个数字的区间，代表的几率
            flag=1;//意味着攻击
        }else{
            flag=0;
        }
        return flag;
    }
}

